package com.ruoyi.demo.controller.app;

import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysDictType;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.file.FileTypeUtils;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.common.utils.file.ImageUtils;
import com.ruoyi.system.service.ISysDictTypeService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;


@Api(tags = "小程序-系统管理接口")
@Slf4j
@RestController
@RequestMapping("/app/system")
@RequiredArgsConstructor
public class AppSystemController extends BaseController {

    private final ISysDictTypeService dictTypeService;

    @ApiOperation("获取字典类型列表")
    @GetMapping("/dict/types")
    public AjaxResult getDictTypes() {
        try {
            List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll();
            return AjaxResult.success(dictTypes);
        } catch (Exception e) {
            log.error("获取字典类型列表异常", e);
            return AjaxResult.error("获取字典类型列表失败");
        }
    }

    @ApiOperation("根据字典类型获取字典数据")
    @Parameter(name = "dictType", description = "字典类型", required = true)
    @GetMapping("/dict/data/{dictType}")
    public AjaxResult getDictData(@PathVariable String dictType) {
        try {
            List<SysDictData> dictData = dictTypeService.selectDictDataByType(dictType);
            return AjaxResult.success(dictData);
        } catch (Exception e) {
            log.error("获取字典数据异常", e);
            return AjaxResult.error("获取字典数据失败");
        }
    }

    @ApiOperation("通用图片上传")
    @PostMapping("/upload")
    public AjaxResult uploadFile(
            @RequestParam(value = "file", required = false) MultipartFile file,
            @RequestParam(value = "url", required = false) String imageUrl) {
        log.info("开始处理图片上传请求 - file: {}, imageUrl: {}", file != null ? file.getOriginalFilename() : "null", imageUrl);
        try {
            // 检查参数
            if (file == null && StringUtils.isEmpty(imageUrl)) {
                log.warn("请求参数错误：文件和URL都为空");
                return AjaxResult.error("请提供文件或URL");
            }
            if (file != null && !file.isEmpty() && !StringUtils.isEmpty(imageUrl)) {
                log.warn("请求参数错误：文件和URL不能同时提供");
                return AjaxResult.error("文件和URL不能同时提供");
            }

            String filePath;
            if (file != null && !file.isEmpty()) {
                // 文件上传方式
                log.info("使用文件上传方式 - 原始文件名: {}, 文件大小: {} bytes", file.getOriginalFilename(), file.getSize());
                // 验证文件类型
                String extension = FileUploadUtils.getExtension(file);
                log.info("文件扩展名: {}", extension);
                if (!isValidImageExtension(extension)) {
                    log.warn("文件类型验证失败 - 不支持的扩展名: {}", extension);
                    return AjaxResult.error("只能上传jpg、jpeg、gif、png格式的图片");
                }
                // 上传文件
                filePath = FileUploadUtils.upload(RuoYiConfig.getUploadPath(), file);
                log.info("文件上传成功 - 保存路径: {}", filePath);
            } else {
                // URL方式
                log.info("使用URL方式下载图片 - URL: {}", imageUrl);
                // 下载图片
                byte[] imageData = ImageUtils.readFile(imageUrl);
                if (imageData == null) {
                    log.error("图片下载失败 - URL: {}", imageUrl);
                    return AjaxResult.error("无法下载图片");
                }
                log.info("图片下载成功 - 数据大小: {} bytes", imageData.length);
                // 验证文件类型
                String extension = FileTypeUtils.getFileExtendName(imageData).toLowerCase();
                log.info("文件扩展名: {}", extension);
                if (!isValidImageExtension(extension)) {
                    log.warn("文件类型验证失败 - 不支持的扩展名: {}", extension);
                    return AjaxResult.error("只能上传jpg、jpeg、gif、png格式的图片");
                }
                // 保存图片
                filePath = FileUtils.writeBytes(imageData, RuoYiConfig.getUploadPath());
                log.info("文件保存成功 - 保存路径: {}", filePath);
            }

            // 处理文件路径，确保返回格式为 /profile/upload/xxx/xxx.jpg
            String resultUrl = filePath.substring(filePath.indexOf("/profile"));
            log.info("图片上传完成 - 最终访问URL: {}", resultUrl);

            HashMap<String, Object> data = new HashMap<>();
            data.put("fileName", resultUrl);
            return AjaxResult.success(data);
        } catch (Exception e) {
            log.error("图片上传处理失败", e);
            return AjaxResult.error(e.getMessage());
        }
    }


    /**
     * 验证图片扩展名
     */
    protected boolean isValidImageExtension(String extension) {
        if (StringUtils.isEmpty(extension)) {
            return false;
        }
        String[] allowedExtensions = {"jpg", "jpeg", "gif", "png"};
        return Arrays.asList(allowedExtensions).contains(extension.toLowerCase());
    }
}
